package com.ty.tour.common.utils;


import com.ty.tour.common.enums.DateEnum;

import java.sql.Time;
import java.sql.Timestamp;
import java.text.DateFormat;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.*;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

/**
 * 日期工具
 *
 * @author Caoxiaofeng
 * 2018-10-18
 **/

public class DateUtil {
    private static final String REG = "^([01][0-9]|2[0-3]):[0-5][0-9]:[0-5][0-9]";

    // ==格式到年或年月==
    // 日期格式，年份，例如：2004，2008
    public static final String DATE_FORMAT_YYYY = "yyyy";
    // 日期格式，年份和月份，例如：200707，200808
    public static final String DATE_FORMAT_YYYYMM = "yyyyMM";
    // 日期格式，年份和月份，例如：2007-07，2008-08
    public static final String DATE_FORMAT_YYYY_MM = "yyyy-MM";


    // ==格式到年月日==
    // 日期格式，年月日，用横杠分开，例如：06-12-25，08-08-08
    public static final String DATE_FORMAT_YY_MM_DD = "yy-MM-dd";
    // 日期格式，年月日，例如：20050630，20080808
    public static final String DATE_FORMAT_YYYYMMDD = "yyyyMMdd";
    // 日期格式，年月日，用横杠分开，例如：2006-12-25，2008-08-08
    public static final String DATE_FORMAT_YYYY_MM_DD = "yyyy-MM-dd";


    // ==格式到年月日 时分==
    // 日期格式，年月日时分，例如：20001230 12:00，20080808 20:08
    public static final String DATE_TIME_FORMAT_YYYYMMDD_HH_MI = "yyyyMMdd HH:mm";
    // 日期格式，年月日时分，例如：2000-12-30 12:00，2008-08-08 20:08
    public static final String DATE_TIME_FORMAT_YYYY_MM_DD_HH_MI = "yyyy-MM-dd HH:mm";


    // ==格式到年月日 时分秒==
    // 日期格式，年月日时分秒，例如：20001230120000，20080808200808
    public static final String DATE_TIME_FORMAT_YYYYMMDDHHMISS = "yyyyMMddHHmmss";
    // 日期格式，年月日时分秒，年月日用横杠分开，时分秒用冒号分开
    // 例如：2005-05-10 23：20：00，2008-08-08 20:08:08
    public static final String DATE_TIME_FORMAT_YYYY_MM_DD_HH_MI_SS = "yyyy-MM-dd HH:mm:ss";


    // ==格式到年月日 时分秒 毫秒==
    //日期格式，年月日时分秒毫秒，例如：20001230120000123，20080808200808456
    public static final String DATE_TIME_FORMAT_YYYYMMDDHHMISSSSS = "yyyyMMddHHmmssSSS";


    // ==特殊格式==
    //日期格式，月日时分，例如：10-05 12:00
    public static final String DATE_FORMAT_MMDDHHMI = "MM-dd HH:mm";



    /*  ************工具方法开始***************   */

    /**
     * @param time String时间
     * @return 是否符合(09 : 00 : 00 返回true)
     * @desc 是否符合(00 : 00 : 00 - 23 : 59 : 59时间规范)
     */
    public static Boolean isTime(String time) {
        // TODO 9:00:00 返回false 修改正则
        Pattern p = Pattern.compile(REG);
        Matcher m = p.matcher(time);
        return m.matches();
    }

    /**
     * @param date 日期
     * @return String
     * @desc Date 类型转换成 String
     */
    public static String dateToLongString(Date date) {
        String dt = "";
        try {
            DateFormat dateFormat = new SimpleDateFormat(DateEnum.DATE_TIME_FORMAT_YYYY_MM_DD_HH_MI_SS.getString());
            dt = dateFormat.format(date);
        } catch (Exception e) {
            e.printStackTrace();
        }
        return dt;
    }

    /**
     * 将时间转换为特定格式
     *
     * @param date
     * @return
     */
    public static String dateToString(Date date) {
        String dt = "";
        try {
            DateFormat dateFormat = new SimpleDateFormat(DateEnum.DATE_FORMAT_YYYYMMDD.getString());
            dt = dateFormat.format(date);
        } catch (Exception e) {
            e.printStackTrace();
        }
        return dt;
    }

    /**
     * @param date 日期
     * @return String
     * @desc Date 类型转换成 String
     */
    public static String dateToShortString(Date date) {
        String dt = "";
        try {
            DateFormat dateFormat = new SimpleDateFormat(DateEnum.DATE_FORMAT_YYYY_MM_DD.getString());
            dt = dateFormat.format(date);
        } catch (Exception e) {
            e.printStackTrace();
        }
        return dt;
    }

    /**
     * @param date 原有日期
     * @param days 天数
     * @return 新日期
     * @desc 延长日期
     */
    public static Date proLongDate(Date date, long days) {
        long time = date.getTime();
        days = days * 24 * 60 * 60 * 1000;
        time += days;
        return new Date(time);
    }

    /**
     * @param before 传比较时间(...)
     * @param after  传现在时间(new Date())
     * @return is
     * @desc 比较两个时间大小
     * 默认false，前大于后返回true
     */
    public static boolean compareDate(Date before, Date after) {
        if (null == before || null == after) return false;
        boolean is = false;
        if (before.compareTo(after) > 0) {
            is = true;
        }
        return is;
    }

    /**
     * @param start
     * @param end
     * @return end > start：true ; end < start：false
     * @desc 验证时间先后
     */
    public static Boolean isBehind(Time start, Time end) {
        return end.before(start);
    }

    /**
     * @param date 日期
     * @return 年份
     * @desc 获取某日期的年份
     */
    public static Integer getYear(Date date) {
        Calendar calendar = Calendar.getInstance();
        calendar.setTime(date);
        return calendar.get(Calendar.YEAR);
    }

    /**
     * @param date 日期
     * @return 月份（这里要+1）
     * @desc 获取某日期的月份
     */
    public static Integer getMonth(Date date) {
        Calendar calendar = Calendar.getInstance();
        calendar.setTime(date);
        return calendar.get(Calendar.MONTH) + 1;
    }

    /**
     * @param date 日期
     * @return 天
     * @desc 获取某日期的天
     */
    public static Integer getDay(Date date) {
        Calendar calendar = Calendar.getInstance();
        calendar.setTime(date);
        return calendar.get(Calendar.DATE);
    }

    /**
     * @param date 日期
     * @return 天
     * @desc 获取某日期的天
     */
    public static boolean isDateFormat(String date, String format) {
        SimpleDateFormat f = new SimpleDateFormat(format);
        try {
            f.parse(date);
        } catch (ParseException e) {
            return false;
        }
        return true;
    }

    /**
     * @param timeString 时间String
     * @return date类型
     * @desc String 转换 成date类型
     * 格式为：2018-09-09 09:09:09 或者 2018-09-09
     */
    public static Date stringToDate(String timeString) {
        if (timeString == null || timeString.equals("")) {
            return null;
        }
        DateFormat dateFormat = new SimpleDateFormat(DateEnum.DATE_TIME_FORMAT_YYYY_MM_DD_HH_MI_SS.getString());
        Date date = null;
        try {
            date = dateFormat.parse(timeString);
        } catch (ParseException e) {
            try {
                dateFormat = new SimpleDateFormat(DateEnum.DATE_FORMAT_YYYY_MM_DD.getString());
                date = dateFormat.parse(timeString);
            } catch (ParseException e1) {
                e1.printStackTrace();
            }
        }
        return date;
    }

    /**
     * @param time   String类型时间：2018-10-19 09:09:09
     * @param format String类型格式：yyyy-MM-dd
     * @return 格式化后的Date日期
     * @desc 格式化String时间
     */
    public static Date parseStringToDateByFormat(String time, String format) {
        if (time == null || time.equals("")) {
            return null;
        }
        Date date = null;
        try {
            DateFormat dateFormat = new SimpleDateFormat(format);
            date = dateFormat.parse(time);
        } catch (Exception e) {
            e.printStackTrace();
        }
        return date;
    }

    /**
     * @param expire 有效期
     * @return >0未过期，<0过期，=0错误或者时间相等
     * @desc 过期天数(正1 / 负2)
     */
    public static int yetExpireDay(Date expire) {
        if (null == expire) return 0;
        return (int) ((expire.getTime() - new Date().getTime()) / (1000 * 3600 * 24));
    }

    /**
     * @param time 毫秒
     * @return 00:00:00
     * @desc 4000ms --> 4S
     */
    public static String msToString(int time) {
        // 小于一分钟
        if (time < 60000) {
            // 小于10S
            if (time < 10000) {
                return "00:00:0" + (time % 60000) / 1000;
            } else {
                return "00:00:" + (time % 60000) / 1000;
            }
        }
        // 小于一小时
        else if (time > 60000 && time < 3600000) {
            return getHourMinSecond((time % 3600000) / 60000) + ":"
                    + getHourMinSecond((time % 60000) / 1000);
        }
        // 大于一小时
        else {
            return getHourMinSecond(time / 3600000) + ":"
                    + getHourMinSecond((time % 3600000) / 60000) + ":"
                    + getHourMinSecond((time % 60000) / 1000);
        }
    }


    /**
     * @param beginDateString 开始日期 格式：yyyy-MM
     * @param endDateString   结束日期 格式：yyyy-MM
     * @return yyyy-MM日期集合
     * @desc 解析两个日期之间的所有月份
     */
    public static List<String> getMonthListOfDates(String beginDateString, String endDateString) {
        // 指定要解析的时间格式（这里指定的是：yyyy-MM）
        SimpleDateFormat f = new SimpleDateFormat(DateEnum.DATE_FORMAT_YYYY_MM.getString());
        // 返回的月份列表
        String sRet = "";

        // 定义一些变量
        Date beginDate = null;
        Date endDate = null;

        GregorianCalendar beginGC = null;
        GregorianCalendar endGC = null;
        List<String> list = new ArrayList<String>();

        try {
            // 将字符串parse成日期
            beginDate = f.parse(beginDateString);
            endDate = f.parse(endDateString);

            // 设置日历
            beginGC = new GregorianCalendar();
            beginGC.setTime(beginDate);

            endGC = new GregorianCalendar();
            endGC.setTime(endDate);

            // 直到两个时间相同
            while (beginGC.getTime().compareTo(endGC.getTime()) <= 0) {
                sRet = beginGC.get(Calendar.YEAR) + "-"
                        + (beginGC.get(Calendar.MONTH) + 1);
                list.add(sRet);
                // 以月为单位，增加时间
                beginGC.add(Calendar.MONTH, 1);
            }
            return list;
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
    }

    /**
     * @param beginDateString 开始日期  格式：yyyy-MM-dd
     * @param endDateString   结束日期  格式：yyyy-MM-dd
     * @return yyyy-MM-dd日期集合
     * @desc 解析两个日期段之间的所有日期
     */
    public static List<String> getDayListOfDates(String beginDateString, String endDateString) {
        // 指定要解析的时间格式（这里指定的是：yyyy-MM-dd）
        SimpleDateFormat f = new SimpleDateFormat(DateEnum.DATE_FORMAT_YYYY_MM_DD.getString());

        // 定义一些变量
        Date beginDate = null;
        Date endDate = null;

        Calendar beginGC = null;
        Calendar endGC = null;
        List<String> list = new ArrayList<String>();

        try {
            // 将字符串parse成日期
            beginDate = f.parse(beginDateString);
            endDate = f.parse(endDateString);

            // 设置日历
            beginGC = Calendar.getInstance();
            beginGC.setTime(beginDate);

            endGC = Calendar.getInstance();
            endGC.setTime(endDate);
            SimpleDateFormat sdf = new SimpleDateFormat(DateEnum.DATE_FORMAT_YYYY_MM_DD.getString());

            // 直到两个时间相同
            while (beginGC.getTime().compareTo(endGC.getTime()) <= 0) {

                list.add(sdf.format(beginGC.getTime()));
                // 以日为单位，增加时间
                beginGC.add(Calendar.DAY_OF_MONTH, 1);
            }
            return list;
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
    }

    /**
     * @param before 当下年份前年数
     * @param behind 当下年份后年数
     * @return 集合
     * @desc 获取当下年份指定前后数量的年份集合
     */
    public static List<Integer> getYearListOfYears(int before, int behind) {
        if (before < 0 || behind < 0) {
            return null;
        }
        List<Integer> list = new ArrayList<Integer>();
        Calendar calendar = null;
        calendar = Calendar.getInstance();
        calendar.setTime(new Date());
        int currYear = Calendar.getInstance().get(Calendar.YEAR);

        int startYear = currYear - before;
        int endYear = currYear + behind;
        for (int i = startYear; i < endYear; i++) {
            list.add(i);
        }
        return list;
    }

    /**
     * @param date 日期
     * @return 第几周
     * @desc 获取当前日期是一年中第几周
     */
    public static Integer getWeekendOfYearFromDate(Date date) {
        Calendar c = new GregorianCalendar();
        c.setFirstDayOfWeek(Calendar.MONDAY);
        c.setMinimalDaysInFirstWeek(7);
        c.setTime(date);

        return c.get(Calendar.WEEK_OF_YEAR);
    }

    /**
     * @param year 年份
     * @return 总周数
     * @desc 获取某一年的总周数
     */
    public static Integer getWeekCountOfYear(int year) {
        Calendar c = new GregorianCalendar();
        c.set(year, Calendar.DECEMBER, 31, 23, 59, 59);
        return getWeekendOfYearFromDate(c.getTime());
    }

    /**
     * @param year 目标年份
     * @param week 目标周数
     * @return 第一天
     * @desc 获取某年某周的第一天
     */
    public static Date getFirstDayOfYearAndWeek(int year, int week) {
        Calendar c = new GregorianCalendar();
        c.set(Calendar.YEAR, year);
        c.set(Calendar.MONTH, Calendar.JANUARY);
        c.set(Calendar.DATE, 1);

        Calendar cal = (GregorianCalendar) c.clone();
        cal.add(Calendar.DATE, week * 7);

        return getFirstDayOfWeek(cal.getTime());
    }

    /**
     * @param year 目标年份
     * @param week 目标周数
     * @return 最后一天
     * @desc 获取某年某周的最后一天
     */
    public static Date getLastDayOfYearAndWeek(int year, int week) {
        Calendar c = new GregorianCalendar();
        c.set(Calendar.YEAR, year);
        c.set(Calendar.MONTH, Calendar.JANUARY);
        c.set(Calendar.DATE, 1);

        Calendar cal = (GregorianCalendar) c.clone();
        cal.add(Calendar.DATE, week * 7);

        return getLastDayOfWeek(cal.getTime());
    }

    /**
     * @param year  目标年份
     * @param month 目标月份
     * @return 第一天
     * @desc 获取某年某月的第一天
     */
    public static Date getFirstDayOfYearAndMonth(int year, int month) {
        month = month - 1;
        Calendar c = Calendar.getInstance();
        c.set(Calendar.YEAR, year);
        c.set(Calendar.MONTH, month);

        int day = c.getActualMinimum(c.DAY_OF_MONTH);

        c.set(Calendar.DAY_OF_MONTH, day);
        c.set(Calendar.HOUR_OF_DAY, 0);
        c.set(Calendar.MINUTE, 0);
        c.set(Calendar.SECOND, 0);
        c.set(Calendar.MILLISECOND, 0);
        return c.getTime();
    }

    /**
     * @param year  目标年份
     * @param month 目标月份
     * @return
     * @desc 获取某年某月的最后一天
     */
    public static Date getLastDayOfYearAndMonth(int year, int month) {
        month = month - 1;
        Calendar c = Calendar.getInstance();
        c.set(Calendar.YEAR, year);
        c.set(Calendar.MONTH, month);
        int day = c.getActualMaximum(c.DAY_OF_MONTH);
        c.set(Calendar.DAY_OF_MONTH, day);
        c.set(Calendar.HOUR_OF_DAY, 23);
        c.set(Calendar.MINUTE, 59);
        c.set(Calendar.SECOND, 59);
        c.set(Calendar.MILLISECOND, 999);
        return c.getTime();
    }

    /**
     * @param date 日期
     * @return String "星期*"
     * @desc 获取某个日期为星期几
     */
    public static String getDayWeekOfDate_String(Date date) {
        String[] weekDays = {
                DateEnum.SUNDAY.getString(),
                DateEnum.MONDAY.getString(),
                DateEnum.TUESDAY.getString(),
                DateEnum.WEDNESDAY.getString(),
                DateEnum.THURSDAY.getString(),
                DateEnum.FRIDAY.getString(),
                DateEnum.SATURDAY.getString()
        };
        Calendar cal = Calendar.getInstance();
        cal.setTime(date);

        int w = cal.get(Calendar.DAY_OF_WEEK) - 1;
        if (w < 0)
            w = 0;
        return weekDays[w];
    }

    /**
     * @param date 日期
     * @return int 0->星期日,1->星期一,2->星期二...6->星期六
     * @desc 获得指定日期的星期几（数）
     */
    public static Integer getDayWeekOfDate_int(Date date) {
        Calendar calendar = Calendar.getInstance();
        calendar.setTime(date);
        return calendar.get(Calendar.DAY_OF_WEEK) - 1;
    }

    /**
     * @param string 目标字符串
     * @return 是，否
     * @desc 判断是否为时间格式：yyyy-MM-dd HH:mm:ss
     * 设置lenient为false. 否则SimpleDateFormat会比较宽松地验证日期
     * 比如2007-02-29会被接受，并转换成2007-03-01
     */
    public static boolean isValidDate_ymdhms(String string) {
        boolean convertSuccess = true;
        // 指定日期格式为yyyy-MM-dd HH:mm:ss区分大小写；
        SimpleDateFormat format = new SimpleDateFormat(DateEnum.DATE_TIME_FORMAT_YYYY_MM_DD_HH_MI_SS.getString());
        try {
            format.setLenient(false);
            format.parse(string);
        } catch (ParseException e) {
            convertSuccess = false;
        }
        return convertSuccess;
    }

    public static boolean isValidDate_ymd(String string) {
        boolean convertSuccess = true;
        // 指定日期格式为yyyy-MM-dd区分大小写；
        SimpleDateFormat format = new SimpleDateFormat(DateEnum.DATE_FORMAT_YYYY_MM_DD.getString());
        try {
            format.setLenient(false);
            format.parse(string);
        } catch (ParseException e) {
            convertSuccess = false;
        }
        return convertSuccess;
    }


    /**
     * @param date        指定日期
     * @param year        年数，可正可负
     * @param month       月数，可正可负
     * @param day         天数，可正可负
     * @param hour        小时数，可正可负
     * @param minute      分钟数，可正可负
     * @param second      秒数，可正可负
     * @param millisecond 毫秒数，可正可负
     * @return 计算后的日期
     * @desc 获得指定时间加减参数后的日期(不计算则输入0)
     */
    public static Date calculateDate(Date date, int year, int month, int day,
                                     int hour, int minute, int second, int millisecond) {
        Calendar c = Calendar.getInstance();
        c.setTime(date);
        c.add(Calendar.YEAR, year);//加减年数
        c.add(Calendar.MONTH, month);//加减月数
        c.add(Calendar.DATE, day);//加减天数
        c.add(Calendar.HOUR, hour);//加减小时数
        c.add(Calendar.MINUTE, minute);//加减分钟数
        c.add(Calendar.SECOND, second);//加减秒
        c.add(Calendar.MILLISECOND, millisecond);//加减毫秒数

        return c.getTime();
    }

    /**
     * @param startDate 开始时间
     * @param endDate   结束时间
     * @return 天
     * @desc 获得两个日期的时间戳之差（结束 - 开始）
     */
    public static Long getDistanceTimestamp(Date startDate, Date endDate) {
        return (endDate.getTime() - startDate.getTime() + 1000000) / (3600 * 24 * 1000);
    }

    /**
     * @param startDate
     * @param endDate
     * @return
     * @desc 获取两个时间相差多少天
     */
    public static int getDistanceDay(Date startDate, Date endDate) {
        if (null == startDate || null == endDate) return 0;
        return getDistance_day(startDate, endDate);
    }

    /**
     * @param from String 开始时间
     * @param to   String 结束时间
     * @return 相差的天数，小时数，分钟数Map集合
     * @desc 获得两个String日期的时间差（结束 - 开始）
     * 格式：yyyy-MM-dd HH:mm:ss
     */
    public static Map<String, Integer> getDistance(String from, String to) {
        Map<String, Integer> map = new HashMap<>();
        try {
            SimpleDateFormat simpleFormat = new SimpleDateFormat(DateEnum.DATE_TIME_FORMAT_YYYY_MM_DD_HH_MI_SS.getString());
            Date fromDate = simpleFormat.parse(from);
            Date toDate = simpleFormat.parse(to);

            map.put(DateEnum.DAY.getString(), getDistance_day(fromDate, toDate));
            map.put(DateEnum.HOUR.getString(), getDistance_hour(fromDate, toDate));
            map.put(DateEnum.MINUTE.getString(), getDistance_minute(fromDate, toDate));

            return map;
        } catch (ParseException e) {
            e.printStackTrace();
            return null;
        }
    }

    /**
     * @param date_first  第一个时间
     * @param date_second 第二个时间
     * @return 是，否
     * @desc 判断二个时间是否为同年同月
     */
    public static Boolean compareIsSameYearAndMonth(Date date_first, Date date_second) {
        boolean flag = false;
        int year1 = getYear(date_first);
        int year2 = getYear(date_second);
        if (year1 == year2) {
            int month1 = getMonth(date_first);
            int month2 = getMonth(date_second);
            if (month1 == month2) flag = true;
        }
        return flag;
    }

    /**
     * @param from 时间参数 1 格式：1990-01-01 12:00:00
     * @param to   时间参数 2 格式：2009-01-01 12:00:00
     * @return Map ：{天, 时, 分, 秒}
     * @desc 获得两个时间相差：多少天多少小时多少分多少秒
     */
    public static Map<String, Long> getDistanceTime(Date from, Date to) {
        Map<String, Long> map = new HashMap<>();
        long day = 0, hour = 0, min = 0, sec = 0;
        try {
            long time1 = from.getTime();
            long time2 = to.getTime();
            long diff;
            if (time1 < time2) {
                diff = time2 - time1;
            } else {
                diff = time1 - time2;
            }
            day = diff / (24 * 60 * 60 * 1000);
            hour = (diff / (60 * 60 * 1000) - day * 24);
            min = ((diff / (60 * 1000)) - day * 24 * 60 - hour * 60);
            sec = (diff / 1000 - day * 24 * 60 * 60 - hour * 60 * 60 - min * 60);
        } catch (Exception e) {
            e.printStackTrace();
        }
        map.put(DateEnum.DAY.getString(), day);
        map.put(DateEnum.HOUR.getString(), hour);
        map.put(DateEnum.MINUTE.getString(), min);
        map.put(DateEnum.SECOND.getString(), sec);
        return map;
    }

    /**
     * @param date 指定时间
     * @return time
     * @desc 获取指定时间的那天 00:00:00.000 的时间
     */
    public static Date getDayBeginTime(final Date date) {
        Calendar c = Calendar.getInstance();
        c.setTime(date);
        c.set(Calendar.HOUR_OF_DAY, 0);
        c.set(Calendar.MINUTE, 0);
        c.set(Calendar.SECOND, 0);
        c.set(Calendar.MILLISECOND, 0);
        return c.getTime();
    }

    /**
     * @param date 指定时间
     * @return time
     * @desc 获取指定时间的那天 23:59:59.999 的时间
     */
    public static Date getDayEndTime(final Date date) {
        Calendar c = Calendar.getInstance();
        c.setTime(date);
        c.set(Calendar.HOUR_OF_DAY, 23);
        c.set(Calendar.MINUTE, 59);
        c.set(Calendar.SECOND, 59);
        c.set(Calendar.MILLISECOND, 999);
        return c.getTime();
    }

    /**
     * @param days
     * @return
     * @desc 获取过去第 days 天的日期
     */
    public static String getPastDate(int days) {
        Calendar calendar = Calendar.getInstance();
        calendar.set(Calendar.DAY_OF_YEAR, calendar.get(Calendar.DAY_OF_YEAR) - days);
        Date today = calendar.getTime();
        SimpleDateFormat format = new SimpleDateFormat(DateEnum.DATE_FORMAT_YYYY_MM_DD.getString());
        return format.format(today);
    }

    /**
     * @param days
     * @return
     * @desc 获取未来 第 days 天的日期
     */
    public static String getFeatureDate(int days) {
        Calendar calendar = Calendar.getInstance();
        calendar.set(Calendar.DAY_OF_YEAR, calendar.get(Calendar.DAY_OF_YEAR) + days);
        Date today = calendar.getTime();
        SimpleDateFormat format = new SimpleDateFormat(DateEnum.DATE_FORMAT_YYYY_MM_DD.getString());
        return format.format(today);
    }

    /**
     * @param time   Date类型时间
     * @param format String类型格式
     * @return 格式化后的字符串
     * @desc 格式化Date时间
     */
    public static String parseDateToStringByFormat(Date time, String format) {
        DateFormat dateFormat = new SimpleDateFormat(format);
        return dateFormat.format(time);
    }

    /**
     * @param date 2018-01-02
     * @return "2018-01-01"
     * @desc 获取时间的前一天
     */
    public static String yesterday(Date date) {
        SimpleDateFormat sdf = new SimpleDateFormat(DateEnum.DATE_FORMAT_YYYY_MM_DD.getString());
        Calendar calendar = new GregorianCalendar();
        calendar.setTime(date);
        calendar.add(calendar.DATE, -1);
        return sdf.format(calendar.getTime());
    }

    /**
     * @param date 2018-01-02
     * @return "2018-01-02"
     * @desc 获取时间的当天
     */
    public static String today(Date date) {
        SimpleDateFormat sdf = new SimpleDateFormat(DateEnum.DATE_FORMAT_YYYY_MM_DD.getString());
        return sdf.format(date);
    }

    // ===================== private ==========================

    /**
     * @param date 指定日期
     * @return date类型的第一天
     * @desc 获取指定日期所在周的第一天
     */
    private static Date getFirstDayOfWeek(Date date) {
        Calendar c = new GregorianCalendar();
        c.setFirstDayOfWeek(Calendar.MONDAY);
        c.setTime(date);
        c.set(Calendar.DAY_OF_WEEK, c.getFirstDayOfWeek()); // Monday
        return c.getTime();
    }


    /**
     * @param date 指定日期
     * @return 最后一天
     * @desc 获取指定日期所在周的最后一天
     */
    private static Date getLastDayOfWeek(Date date) {
        Calendar c = new GregorianCalendar();
        c.setFirstDayOfWeek(Calendar.MONDAY);
        c.setTime(date);
        c.set(Calendar.DAY_OF_WEEK, c.getFirstDayOfWeek() + 6); // Sunday
        return c.getTime();
    }

    /**
     * @param timestamp Timestamp类型时间
     * @param format    String格式
     * @return 格式化后的字符串
     * @desc 格式化Timestamp时间
     */
    private static String parseTimestampToStringByFormat(Timestamp timestamp, String format) {
        SimpleDateFormat df = new SimpleDateFormat(format);
        return df.format(timestamp);
    }

    /**
     * @param date   Date ：date类型的时间 new Date()
     * @param format String ：string类型的格式"yyyy-MM-dd"
     * @param time   默认值为当前时间Date()
     * @return 格式化后的字符串
     * @desc 格式化Date时间：或当前时间
     */
    private static String parseDateToString_Time(Date date, String format, final Date time) {
        try {
            DateFormat dateFormat = new SimpleDateFormat(format);
            return dateFormat.format(date);
        } catch (Exception e) {
            if (time != null)
                return parseDateToStringByFormat(time, format);
            else
                return parseDateToStringByFormat(new Date(), format);
        }
    }

    private static String getHourMinSecond(int time) {
        String str = "";
        if (time > 0) {
            if (time < 10) {
                str = "0" + time;
            } else {
                str = time + "";
            }
        } else {
            str = "00";
        }
        return str;
    }

    /**
     * @param date   Date类型时间
     * @param format String类型格式
     * @param string 默认时间值String类型
     * @return 格式化后的字符串
     * @desc 格式化Date时间：
     */
    private static String parseDateToString_String(Date date, String format, final String string) {
        try {
            DateFormat dateFormat = new SimpleDateFormat(format);
            return dateFormat.format(date);
        } catch (Exception e) {
            return string;
        }
    }

    /**
     * @return
     * @desc 获取当天开始时间
     */
    public static Date getDayBegin() {
        Calendar cal = new GregorianCalendar();
        cal.set(Calendar.HOUR_OF_DAY, 0);
        cal.set(Calendar.MINUTE, 0);
        cal.set(Calendar.SECOND, 0);
        cal.set(Calendar.MILLISECOND, 0);
        return cal.getTime();
    }

    /**
     * @return
     * @desc 获取当天的结束时间
     */
    public static Date getDayEnd() {
        Calendar cal = new GregorianCalendar();
        cal.set(Calendar.HOUR_OF_DAY, 23);
        cal.set(Calendar.MINUTE, 59);
        cal.set(Calendar.SECOND, 59);
        cal.set(Calendar.MILLISECOND, 999);
        return cal.getTime();
    }

    /**
     * @param fromDate 开始时间
     * @param toDate   结束时间
     * @return 天，时，分
     * @desc 计算两个时间相差值（结束 - 开始）
     */
    private static int getDistance_day(Date fromDate, Date toDate) {
        return (int) ((toDate.getTime() - fromDate.getTime()) / (1000 * 60 * 60 * 24));
    }

    private static int getDistance_hour(Date fromDate, Date toDate) {
        return (int) ((toDate.getTime() - fromDate.getTime()) / (1000 * 60 * 60));
    }

    private static int getDistance_minute(Date fromDate, Date toDate) {
        return (int) ((toDate.getTime() - fromDate.getTime()) / (1000 * 60));
    }
}